Système de dépendances FastAPI : Injection de dépendances avancée

Le système d'injection de dépendances (DI) de FastAPI est une pierre angulaire de sa conception, favorisant la modularité, la testabilité et la réutilisabilité. Bien que l'utilisation de base soit simple, la maîtrise des techniques DI avancées débloque une puissance et une flexibilité considérables. Cet article traite de l'injection de dépendances avancée dans FastAPI, couvrant les dépendances personnalisées, les portées, les stratégies de test et les meilleures pratiques.

Comprendre les principes fondamentaux

Avant de plonger dans des sujets avancés, récapitulons rapidement les bases de l'injection de dépendances de FastAPI :

• Dépendances en tant que fonctions : Les dépendances sont déclarées comme des fonctions Python régulières.
• Injection automatique : FastAPI injecte automatiquement ces dépendances dans les opérations de chemin en fonction des indications de type.
• Indications de type en tant que contrats : Les indications de type définissent les types d'entrée attendus pour les dépendances et les fonctions d'opération de chemin.
• Dépendances hiérarchiques : Les dépendances peuvent dépendre d'autres dépendances, créant ainsi un arbre de dépendances.

Voici un exemple simple :

            
from fastapi import FastAPI, Depends

app = FastAPI()

def get_db():
    db = {"items": []}
    try:
        yield db
    finally:
        # Close the connection if needed
        pass

@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

Dans cet exemple, get_db est une dépendance qui fournit une connexion à la base de données. FastAPI appelle automatiquement get_db et injecte le résultat dans la fonction read_items.

Techniques de dépendance avancées

1. Utiliser des classes comme dépendances

Bien que les fonctions soient couramment utilisées, les classes peuvent également servir de dépendances, permettant une gestion et des méthodes d'état plus complexes. Ceci est particulièrement utile lorsque vous traitez des connexions de base de données, des services d'authentification ou d'autres ressources qui nécessitent une initialisation et un nettoyage.

            
from fastapi import FastAPI, Depends

app = FastAPI()

class Database:
    def __init__(self):
        self.connection = self.create_connection()

    def create_connection(self):
        # Simulate a database connection
        print("Creating database connection...")
        return {"items": []}

    def close(self):
        # Simulate closing a database connection
        print("Closing database connection...")

def get_db():
    db = Database()
    try:
        yield db.connection
    finally:
        db.close()

@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

Dans cet exemple, la classe Database encapsule la logique de connexion à la base de données. La dépendance get_db crée une instance de la classe Database et renvoie la connexion. Le bloc finally garantit que la connexion est correctement fermée après le traitement de la requête.

2. Remplacer les dépendances

FastAPI vous permet de remplacer les dépendances, ce qui est essentiel pour les tests et le développement. Vous pouvez remplacer une dépendance réelle par une simulation ou un stub pour isoler votre code et garantir des résultats cohérents.

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Original dependency
def get_settings():
    # Simulate loading settings from a file or environment
    return {"api_key": "real_api_key"}

@app.get("/items/")
async def read_items(settings: dict = Depends(get_settings)):
    return {"api_key": settings["api_key"]}

# Override for testing
def get_settings_override():
    return {"api_key": "test_api_key"}

app.dependency_overrides[get_settings] = get_settings_override

# To revert back to the original:
# del app.dependency_overrides[get_settings]

            

              
                Copy
              
            
          

Dans cet exemple, la dépendance get_settings est remplacée par get_settings_override. Cela vous permet d'utiliser une clé API différente à des fins de test.

3. Utiliser `contextvars` pour les données à portée de requête

contextvars est un module Python qui fournit des variables locales au contexte. Ceci est utile pour stocker des données spécifiques à la requête, telles que des informations d'authentification utilisateur, des ID de requête ou des données de suivi. L'utilisation de contextvars avec l'injection de dépendances de FastAPI vous permet d'accéder à ces données dans toute votre application.

            
import contextvars
from fastapi import FastAPI, Depends, Request

app = FastAPI()

# Create a context variable for the request ID
request_id_var = contextvars.ContextVar("request_id")

# Middleware to set the request ID
@app.middleware("http")
async def add_request_id(request: Request, call_next):
    request_id = str(uuid.uuid4())
    request_id_var.set(request_id)
    response = await call_next(request)
    response.headers["X-Request-ID"] = request_id
    return response

# Dependency to access the request ID
def get_request_id():
    return request_id_var.get()

@app.get("/items/")
async def read_items(request_id: str = Depends(get_request_id)):
    return {"request_id": request_id}

            

              
                Copy
              
            
          

Dans cet exemple, un middleware définit un ID de requête unique pour chaque requête entrante. La dépendance get_request_id récupère l'ID de requête du contexte contextvars. Cela vous permet de suivre les requêtes dans toute votre application.

4. Dépendances asynchrones

FastAPI prend en charge de manière transparente les dépendances asynchrones. Ceci est essentiel pour les opérations d'E/S non bloquantes, telles que les requêtes de base de données ou les appels d'API externes. Définissez simplement votre fonction de dépendance comme une fonction async def.

            
from fastapi import FastAPI, Depends
import asyncio

app = FastAPI()

async def get_data():
    # Simulate an asynchronous operation
    await asyncio.sleep(1)
    return {"message": "Hello from async dependency!"}

@app.get("/items/")
async def read_items(data: dict = Depends(get_data)):
    return data

            

              
                Copy
              
            
          

Dans cet exemple, la dépendance get_data est une fonction asynchrone qui simule un délai. FastAPI attend automatiquement le résultat de la dépendance asynchrone avant de l'injecter dans la fonction read_items.

5. Utilisation de générateurs pour la gestion des ressources (connexions de base de données, handles de fichiers)

L'utilisation de générateurs (avec yield) fournit une gestion automatique des ressources, garantissant que les ressources sont correctement fermées/libérées via le bloc `finally` même en cas d'erreurs.

            
from fastapi import FastAPI, Depends

app = FastAPI()


def get_file_handle():
    try:
        file_handle = open("my_file.txt", "r")
        yield file_handle
    finally:
        file_handle.close()

@app.get("/file_content/")
async def read_file_content(file_handle = Depends(get_file_handle)):
    content = file_handle.read()
    return {"content": content}

            

              
                Copy
              
            
          

Portées et cycles de vie des dépendances

Comprendre les portées des dépendances est essentiel pour gérer le cycle de vie des dépendances et garantir que les ressources sont correctement allouées et libérées. FastAPI n'offre pas directement d'annotations de portée explicites comme certains autres frameworks DI (par exemple, `@RequestScope`, `@ApplicationScope` de Spring), mais la combinaison de la façon dont vous définissez les dépendances et de la façon dont vous gérez l'état permet d'obtenir des résultats similaires.

Portée de la requête

Il s'agit de la portée la plus courante. Chaque requête reçoit une nouvelle instance de la dépendance. Ceci est généralement réalisé en créant un nouvel objet à l'intérieur d'une fonction de dépendance et en le renvoyant, comme indiqué dans l'exemple de la base de données précédemment. L'utilisation de contextvars permet également d'obtenir une portée de requête.

Portée de l'application (Singleton)

Une seule instance de la dépendance est créée et partagée entre toutes les requêtes tout au long du cycle de vie de l'application. Ceci est souvent fait en utilisant des variables globales ou des attributs au niveau de la classe.

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Singleton instance
GLOBAL_SETTING = {"api_key": "global_api_key"}

def get_global_setting():
    return GLOBAL_SETTING

@app.get("/items/")
async def read_items(setting: dict = Depends(get_global_setting)):
    return setting

            

              
                Copy
              
            
          

Soyez prudent lorsque vous utilisez des dépendances à portée d'application avec un état mutable, car les modifications apportées par une requête peuvent affecter d'autres requêtes. Des mécanismes de synchronisation (verrous, etc.) peuvent être nécessaires si votre application a des requêtes simultanées.

Portée de la session (données spécifiques à l'utilisateur)

Associez les dépendances aux sessions utilisateur. Cela nécessite un mécanisme de gestion de session (par exemple, en utilisant des cookies ou des JWT) et implique généralement le stockage des dépendances dans les données de session.

            
from fastapi import FastAPI, Depends, Cookie
from typing import Optional
import uuid

app = FastAPI()

# In a real app, store sessions in a database or cache
sessions = {}

async def get_user_id(session_id: Optional[str] = Cookie(None)) -> str:
    if session_id is None or session_id not in sessions:
        session_id = str(uuid.uuid4())
        sessions[session_id] = {"user_id": str(uuid.uuid4())} # Assign a random user ID
        
    return sessions[session_id]["user_id"]

@app.get("/profile/")
async def read_profile(user_id: str = Depends(get_user_id)):
    return {"user_id": user_id}

            

              
                Copy
              
            
          

Tester les dépendances

L'un des principaux avantages de l'injection de dépendances est l'amélioration de la testabilité. En découplant les composants, vous pouvez facilement remplacer les dépendances par des simulations ou des stubs pendant les tests.

1. Remplacer les dépendances dans les tests

Comme démontré précédemment, le mécanisme dependency_overrides de FastAPI est idéal pour les tests. Créez des dépendances simulées qui renvoient des résultats prévisibles et utilisez-les pour isoler votre code en cours de test.

            
from fastapi.testclient import TestClient
from fastapi import FastAPI, Depends

app = FastAPI()

# Original dependency
def get_external_data():
    # Simulate fetching data from an external API
    return {"data": "Real external data"}

@app.get("/data/")
async def read_data(data: dict = Depends(get_external_data)):
    return data

# Test
from unittest.mock import MagicMock

def get_external_data_mock():
    return {"data": "Mocked external data"}


def test_read_data():
    app.dependency_overrides[get_external_data] = get_external_data_mock
    client = TestClient(app)
    response = client.get("/data/")
    assert response.status_code == 200
    assert response.json() == {"data": "Mocked external data"}

    # Clean up overrides
    app.dependency_overrides.clear()


            

              
                Copy
              
            
          

2. Utilisation des bibliothèques de simulation

Les bibliothèques comme unittest.mock fournissent des outils puissants pour créer des objets simulés et contrôler leur comportement. Vous pouvez utiliser des simulations pour simuler des dépendances complexes et vérifier que votre code interagit correctement avec elles.

            
import unittest
from unittest.mock import MagicMock

# (Define the FastAPI app and get_external_data as above)

class TestReadData(unittest.TestCase):
    def test_read_data_with_mock(self):
        # Create a mock for the get_external_data dependency
        mock_get_external_data = MagicMock(return_value={"data": "Mocked data from unittest"})

        # Override the dependency with the mock
        app.dependency_overrides[get_external_data] = mock_get_external_data

        client = TestClient(app)
        response = client.get("/data/")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"data": "Mocked data from unittest"})

        # Assert that the mock was called
        mock_get_external_data.assert_called_once()

        # Clean up overrides
        app.dependency_overrides.clear()

            

              
                Copy
              
            
          

3. Injection de dépendances pour les tests unitaires (en dehors du contexte FastAPI)

Même lors des tests unitaires de fonctions *en dehors* des gestionnaires de points de terminaison API, les principes d'injection de dépendances s'appliquent toujours. Au lieu de s'appuyer sur `Depends` de FastAPI, injectez manuellement les dépendances dans la fonction en cours de test.

            
# Example function to test
def process_data(data_source):
    data = data_source.fetch_data()
    # ... process the data ...
    return processed_data

class MockDataSource:
    def fetch_data(self):
        return {"example": "data"}

# Unit test
def test_process_data():
    mock_data_source = MockDataSource()
    result = process_data(mock_data_source)
    # Assertions on the result

            

              
                Copy
              
            
          

Considérations de sécurité avec l'injection de dépendances

L'injection de dépendances, bien que bénéfique, introduit des problèmes de sécurité potentiels si elle n'est pas mise en œuvre avec soin.

1. Confusion des dépendances

Assurez-vous que vous récupérez les dépendances à partir de sources fiables. Vérifiez l'intégrité des packages et utilisez des gestionnaires de packages avec des capacités d'analyse des vulnérabilités. Il s'agit d'un principe général de sécurité de la chaîne d'approvisionnement logicielle, mais il est exacerbé par DI, car vous pourriez injecter des composants provenant de diverses sources.

2. Injection de dépendances malveillantes

Soyez attentif aux dépendances qui acceptent une entrée externe sans validation appropriée. Un attaquant pourrait potentiellement injecter du code ou des données malveillantes via une dépendance compromise. Assainissez toutes les entrées utilisateur et mettez en œuvre des mécanismes de validation robustes.

3. Fuite d'informations via les dépendances

Assurez-vous que les dépendances n'exposent pas par inadvertance des informations sensibles. Examinez le code et la configuration de vos dépendances pour identifier les vulnérabilités potentielles de fuite d'informations.

4. Secrets codés en dur

Évitez de coder en dur les secrets (clés API, mots de passe de base de données, etc.) directement dans votre code de dépendance. Utilisez des variables d'environnement ou des outils de gestion de configuration sécurisés pour stocker et gérer les secrets.

            
import os
from fastapi import FastAPI, Depends

app = FastAPI()


def get_api_key():
    api_key = os.environ.get("API_KEY")
    if not api_key:
        raise ValueError("API_KEY environment variable not set.")
    return api_key

@app.get("/secure_endpoint/")
async def secure_endpoint(api_key: str = Depends(get_api_key)):
    # Use api_key for authentication/authorization
    return {"message": "Access granted"}

            

              
                Copy
              
            
          

Optimisation des performances avec l'injection de dépendances

L'injection de dépendances peut avoir un impact sur les performances si elle n'est pas utilisée judicieusement. Voici quelques stratégies d'optimisation :

1. Minimiser le coût de création des dépendances

Évitez de créer des dépendances coûteuses à chaque requête si possible. Si une dépendance est sans état ou peut être partagée entre les requêtes, envisagez d'utiliser une portée singleton ou de mettre en cache l'instance de dépendance.

2. Initialisation paresseuse

Initialisez les dépendances uniquement lorsqu'elles sont nécessaires. Cela peut réduire le temps de démarrage et la consommation de mémoire, en particulier pour les applications avec de nombreuses dépendances.

3. Mise en cache des résultats de la dépendance

Mettez en cache les résultats des calculs de dépendance coûteux si les résultats sont susceptibles d'être réutilisés. Utilisez des mécanismes de mise en cache (par exemple, Redis, Memcached) pour stocker et récupérer les résultats de la dépendance.

4. Optimiser le graphe des dépendances

Analysez votre graphe des dépendances pour identifier les goulots d'étranglement potentiels. Simplifiez la structure des dépendances et réduisez le nombre de dépendances si possible.

5. Dépendances asynchrones pour les opérations liées aux E/S

Utilisez des dépendances asynchrones lors de l'exécution d'opérations d'E/S bloquantes, telles que les requêtes de base de données ou les appels d'API externes. Cela empêche le blocage du thread principal et améliore la réactivité globale de l'application.

Meilleures pratiques pour l'injection de dépendances FastAPI

• Gardez les dépendances simples : Visez des dépendances petites et ciblées qui effectuent une seule tâche. Cela améliore la lisibilité, la testabilité et la maintenabilité.
• Utilisez les indications de type : Tirez parti des indications de type pour définir clairement les types d'entrée et de sortie attendus des dépendances. Cela améliore la clarté du code et permet à FastAPI d'effectuer une vérification statique des types.
• Documentez les dépendances : Documentez le but et l'utilisation de chaque dépendance. Cela aide les autres développeurs à comprendre comment utiliser et maintenir votre code.
• Testez les dépendances de manière approfondie : Écrivez des tests unitaires pour vos dépendances afin de vous assurer qu'elles se comportent comme prévu. Cela aide à prévenir les bogues et à améliorer la fiabilité globale de votre application.
• Utilisez des conventions de nommage cohérentes : Utilisez des conventions de nommage cohérentes pour vos dépendances afin d'améliorer la lisibilité du code.
• Évitez les dépendances circulaires : Les dépendances circulaires peuvent conduire à un code complexe et difficile à déboguer. Refactorisez votre code pour éliminer les dépendances circulaires.
• Envisagez les conteneurs d'injection de dépendances (facultatif) : Bien que l'injection de dépendances intégrée de FastAPI soit suffisante dans la plupart des cas, envisagez d'utiliser un conteneur d'injection de dépendances dédié (par exemple, `inject`, `autowire`) pour les applications plus complexes.

Conclusion

Le système d'injection de dépendances de FastAPI est un outil puissant qui favorise la modularité, la testabilité et la réutilisabilité. En maîtrisant les techniques avancées, telles que l'utilisation de classes comme dépendances, le remplacement des dépendances et l'utilisation de contextvars, vous pouvez créer des API robustes et évolutives. Comprendre les portées et les cycles de vie des dépendances est essentiel pour gérer efficacement les ressources. Donnez toujours la priorité aux tests approfondis de vos dépendances pour garantir la fiabilité et la sécurité de vos applications. En suivant les meilleures pratiques et en tenant compte des implications potentielles en matière de sécurité et de performances, vous pouvez exploiter tout le potentiel du système d'injection de dépendances de FastAPI.